/**
 * 密码管理器存储模块
 * 负责所有与本地存储相关的功能，包括密码数据的存取和主密码验证
 */
const StorageModule = {
    // 本地存储的键名
    KEYS: {
        MASTER_PASSWORD_HASH: 'masterPasswordHash',
        ENCRYPTED_PASSWORDS: 'encryptedPasswords',
        APP_SETTINGS: 'appSettings',
        SECURITY_SETTINGS: 'security_settings'
    },

    /**
     * 检查是否已经设置主密码
     * @returns {boolean} 是否已设置主密码
     */
    isMasterPasswordSet() {
        return !!localStorage.getItem(this.KEYS.MASTER_PASSWORD_HASH);
    },

    /**
     * 设置主密码并初始化密码库
     * @param {string} masterPassword - 用户设置的主密码
     * @returns {boolean} - 设置是否成功
     */
    setupMasterPassword(masterPassword) {
        try {
            // 生成并存储主密码哈希
            const passwordHash = CryptoModule.hashMasterPassword(masterPassword);
            localStorage.setItem(this.KEYS.MASTER_PASSWORD_HASH, passwordHash);
            
            // 初始化空的密码列表并加密
            const emptyPasswords = [];
            const encrypted = CryptoModule.encryptData(emptyPasswords, masterPassword);
            localStorage.setItem(this.KEYS.ENCRYPTED_PASSWORDS, encrypted);
            
            // 初始化应用设置
            const defaultSettings = {
                autoLogout: 5, // 自动登出时间（分钟）
                theme: 'light',
                rememberLastCategory: true
            };
            localStorage.setItem(this.KEYS.APP_SETTINGS, JSON.stringify(defaultSettings));
            
            // 初始化安全设置
            const securitySettings = {
                autoLogout: 5, // 默认5分钟
                passwordExpiry: 90 // 默认90天
            };
            const encryptedSecuritySettings = CryptoModule.encryptData(securitySettings, masterPassword);
            localStorage.setItem(this.KEYS.SECURITY_SETTINGS, encryptedSecuritySettings);
            
            return true;
        } catch (e) {
            console.error('设置主密码失败:', e);
            return false;
        }
    },

    /**
     * 验证主密码
     * @param {string} password - 输入的主密码
     * @returns {boolean} - 验证是否成功
     */
    verifyMasterPassword(password) {
        const storedHash = localStorage.getItem(this.KEYS.MASTER_PASSWORD_HASH);
        if (!storedHash) return false;
        
        return CryptoModule.verifyMasterPassword(password, storedHash);
    },

    /**
     * 更改主密码
     * @param {string} oldPassword - 旧主密码
     * @param {string} newPassword - 新主密码
     * @returns {boolean} - 是否成功
     */
    changeMasterPassword(oldPassword, newPassword) {
        try {
            // 验证旧密码
            const storedHash = localStorage.getItem(this.KEYS.MASTER_PASSWORD_HASH);
            if (!storedHash || !CryptoModule.verifyMasterPassword(oldPassword, storedHash)) {
                throw new Error('当前主密码错误');
            }

            // 获取所有密码数据
            const passwords = this.getPasswords(oldPassword);
            if (!passwords) {
                throw new Error('获取密码数据失败');
            }

            // 使用新密码重新加密所有数据
            const encryptedData = CryptoModule.encryptData(passwords, newPassword);
            localStorage.setItem(this.KEYS.ENCRYPTED_PASSWORDS, encryptedData);

            // 更新主密码哈希
            const newHash = CryptoModule.hashMasterPassword(newPassword);
            localStorage.setItem(this.KEYS.MASTER_PASSWORD_HASH, newHash);

            // 更新安全设置
            const settings = this.getSecuritySettings();
            const encryptedSettings = CryptoModule.encryptData(settings, newPassword);
            localStorage.setItem(this.KEYS.SECURITY_SETTINGS, encryptedSettings);

            return true;
        } catch (error) {
            console.error('更改主密码失败:', error);
            throw error;
        }
    },

    /**
     * 获取所有密码
     * @param {string} masterPassword - 主密码
     * @returns {Array} - 密码数组
     */
    getPasswords(masterPassword) {
        try {
            const encryptedData = localStorage.getItem(this.KEYS.ENCRYPTED_PASSWORDS);
            if (!encryptedData) return [];
            
            const decryptedData = CryptoModule.decryptData(encryptedData, masterPassword);
            return decryptedData || [];
        } catch (error) {
            console.error('获取密码失败:', error);
            return [];
        }
    },

    /**
     * 保存密码数据
     * @param {Array} passwords - 密码数组
     * @param {string} masterPassword - 主密码
     * @returns {boolean} - 保存是否成功
     */
    savePasswords(passwords, masterPassword) {
        try {
            const encrypted = CryptoModule.encryptData(passwords, masterPassword);
            localStorage.setItem(this.KEYS.ENCRYPTED_PASSWORDS, encrypted);
            return true;
        } catch (e) {
            console.error('保存密码失败:', e);
            return false;
        }
    },

    /**
     * 获取应用设置
     * @returns {Object} - 应用设置对象
     */
    getSettings() {
        const settings = localStorage.getItem(this.KEYS.APP_SETTINGS);
        return settings ? JSON.parse(settings) : {
            autoLogout: 5,
            theme: 'light',
            rememberLastCategory: true
        };
    },

    /**
     * 保存应用设置
     * @param {Object} settings - 应用设置对象
     * @returns {boolean} - 保存是否成功
     */
    saveSettings(settings) {
        try {
            localStorage.setItem(this.KEYS.APP_SETTINGS, JSON.stringify(settings));
            return true;
        } catch (e) {
            console.error('保存设置失败:', e);
            return false;
        }
    },

    /**
     * 导出加密数据
     * @returns {string} - 可以下载的数据URL
     */
    exportData() {
        const data = {
            encryptedPasswords: localStorage.getItem(this.KEYS.ENCRYPTED_PASSWORDS),
            settings: this.getSettings(),
            timestamp: new Date().toISOString()
        };
        
        const blob = new Blob([JSON.stringify(data)], { type: 'application/json' });
        return URL.createObjectURL(blob);
    },

    /**
     * 导入数据
     * @param {string} jsonData - 导入的JSON数据
     * @param {string} masterPassword - 当前主密码（用于验证导入的数据是否可解密）
     * @returns {boolean} - 导入是否成功
     */
    importData(jsonData, masterPassword) {
        try {
            const data = JSON.parse(jsonData);
            
            // 验证导入的数据是否可以用当前主密码解密
            if (data.encryptedPasswords) {
                const passwords = CryptoModule.decryptData(data.encryptedPasswords, masterPassword);
                if (passwords === null) return false;
                
                // 导入成功，保存到本地存储
                localStorage.setItem(this.KEYS.ENCRYPTED_PASSWORDS, data.encryptedPasswords);
                
                // 如果有设置，也导入
                if (data.settings) {
                    localStorage.setItem(this.KEYS.APP_SETTINGS, JSON.stringify(data.settings));
                }
                
                return true;
            }
            return false;
        } catch (e) {
            console.error('导入数据失败:', e);
            return false;
        }
    },

    /**
     * 清除所有数据
     * @returns {boolean} - 清除是否成功
     */
    clearAllData() {
        try {
            localStorage.removeItem(this.KEYS.MASTER_PASSWORD_HASH);
            localStorage.removeItem(this.KEYS.ENCRYPTED_PASSWORDS);
            localStorage.removeItem(this.KEYS.APP_SETTINGS);
            localStorage.removeItem(this.KEYS.SECURITY_SETTINGS);
            return true;
        } catch (e) {
            console.error('清除数据失败:', e);
            return false;
        }
    },

    /**
     * 获取安全设置
     * @returns {Object} 安全设置对象
     */
    getSecuritySettings() {
        try {
            const encryptedSettings = localStorage.getItem(this.KEYS.SECURITY_SETTINGS);
            if (encryptedSettings) {
                // 使用当前主密码解密设置
                const settings = CryptoModule.decryptData(encryptedSettings, PasswordManager.currentMasterPassword);
                if (settings) {
                    return settings;
                }
            }
            // 默认设置
            return {
                autoLogout: 5, // 默认5分钟
                passwordExpiry: 90 // 默认90天
            };
        } catch (error) {
            console.error('获取安全设置失败:', error);
            return {
                autoLogout: 5,
                passwordExpiry: 90
            };
        }
    },

    /**
     * 保存安全设置
     * @param {Object} settings 安全设置对象
     * @returns {boolean} 是否保存成功
     */
    saveSecuritySettings(settings) {
        try {
            // 使用当前主密码加密设置
            const encryptedSettings = CryptoModule.encryptData(settings, PasswordManager.currentMasterPassword);
            localStorage.setItem(this.KEYS.SECURITY_SETTINGS, encryptedSettings);
            return true;
        } catch (error) {
            console.error('保存安全设置失败:', error);
            return false;
        }
    },

    /**
     * 检查密码是否过期
     * @param {string} passwordId 密码ID
     * @returns {boolean} 是否过期
     */
    isPasswordExpired(passwordId) {
        try {
            const passwords = this.getPasswords(PasswordManager.currentMasterPassword);
            if (!passwords || passwords.length === 0) return false;

            const password = passwords.find(p => p.id === passwordId);
            if (!password) return false;

            const settings = this.getSecuritySettings();
            if (settings.passwordExpiry === 0) return false; // 禁用过期检查

            const lastModified = new Date(password.lastModified);
            const now = new Date();
            const daysDiff = (now - lastModified) / (1000 * 60 * 60 * 24);

            return daysDiff >= settings.passwordExpiry;
        } catch (error) {
            console.error('检查密码过期失败:', error);
            return false;
        }
    }
}; 